自定义函数

c++中函数定义一般是下面的方式：

函数返回类型  函数名( 形式参数表列 )
{
    函数体语句;
}

下面列出一个函数的所有组成部分：

注意

函数名称： 这是函数的实际名称。函数名和参数列表一起构成了函数签名。

函数主体： 函数主体包含一组定义函数执行任务的语句。

返回类型： 一个函数可以返回一个值。return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。

参数： 参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。

函数示例

该函数有两个参数 x 和 y，会返回这两个数的和：

#include<iostream>
using namespace std;
int func(int x, int y)  //定义函数，传入参数x, y
{
    return x+y;  //返回x+y;
}
int main()
{
    int sum = func(50, 660);
    cout << sum << endl;
    return 0;
}

运行结果：

710

分析

50 传给了 x，660 传给了 y，最终在函数里计算得到 710 返回到主函数给 sum 进行接收

函数名称： func

函数主体： return x + y;

返回类型： int 类型

参数： 参数 x 和 参数 y

函数声明

函数声明会告诉编译器函数名称及如何调用函数。

函数声明包括以下几个部分：

函数返回类型  函数名( 形式参数表列 )  ;

针对上面定义的函数 func()，以下是函数声明：

int func(int x, int y) ;

在函数声明中，参数的名称并不重要，只有参数的类型是必需的，因此下面也是有效的声明：

int func(int , int ) ;

函数调用

创建 C++自定义函数后，就可以通过调用之来执行它。当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。

调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。

例如上面的程序，我们把函数里面 x+y 跟 主函数传过来的 sum 都打印一下看看：

#include<iostream>
using namespace std;
int func(int x, int y)  //定义函数，传入参数x, y
{
    cout << "func函数内 x+y 的值是："  << x + y << endl;
    return x+y;  //返回x+y;
}
int main()
{
    int sum = func(50, 660);
	cout << "主函数内 sum 的值是："  << sum << endl;
    return 0;
}

运行结果：

func函数内 x+y 的值是：710
主函数内 sum 的值是：710

分析

x+y 跟 sum 的结果是一致的
第 10 行代码中 的 func(50, 660); 即函数调用 :::

函数参数

函数参数分为 形式参数 和 实际参数

形式参数

如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。

形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。

当调用函数时，有三种向函数传递参数的方式：

调用类型	描述
传值调用	该方法把参数的实际值赋值给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。
指针调用	该方法把参数的地址赋值给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
引用调用	该方法把参数的引用赋值给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数

实际参数

即实际传给函数进行计算的数值，例如上面的程序，在主函数中传入的 50 和 660 就是实际参数

    int sum = func(50, 660);
	cout << "主函数内 sum 的值是："  << sum << endl;

传值调用

• 将参数以值的形式传入函数，函数内的操作，不改变原参数。

引用变量作为函数参数 示例代码

#include<bits/stdc++.h>
using namespace std;
void fun(int a){
	a = 1;
}
int main()
{
    int a = 10;
	fun(a);
	cout << "a的值是：" << a << endl; //a的值还是10，没有被改变
    return 0;
}

引用调用

• 将参数以引用的形式传入函数，函数内的操作，会改变原参数。

引用变量作为函数参数 示例代码

#include<bits/stdc++.h>
using namespace std;
void fun(int& a){
	a = 1;
}
int main()
{
    int a = 10;
	fun(a);
	cout << "a的值是：" << a << endl; //a的值是1，被改变了
    return 0;
}

数组变量作为函数参数 示例代码

#include<bits/stdc++.h>
using namespace std;
void fun(int a[]){
	a[0] = 1;
}
int main()
{
    int a[3] = {3,2,1};
	fun(a);
	cout << "a[0]的值是：" << a[0] << endl;
    //a的值是1，被改变了。因为数组传入的就是引用地址。
    return 0;
}

局部变量和全局变量

任何一种编程中，作用域是程序中定义的变量所存在的区域，超过该区域变量就不能被访问。
有以下三个地方可以声明变量：

• 在函数或块内部的局部变量
• 在所有函数外部的全局变量
• 在形式参数的函数参数定义中

我们先来认识一下局部变量、全局变量。

局部变量

在某个函数或块的内部声明的变量称为局部变量。它们只能被该函数或该代码块内部的语句使用。局部变量在函数外部是不可知的。下面是使用局部变量的实例。

• 以函数为例：

局部变量 示例代码

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int a = 10;
	int b = 20;
	int c = 30;
    cout << "在main函数内：" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
    return 0;
}

运行结果：

在main函数内：
a = 10
b = 20
c = 30

分析

这里的 a,b,c 都是 main 函数的局部变量

• 以代码块为例：

局部变量 示例代码

#include<bits/stdc++.h>
using namespace std;
int main()
{
    for(int i=1;i<=1;i++){
		int a = 100;
		int b = 200;
		int c = 300;
		cout << "在for循环内：" << endl;
		cout << "a = " << a << endl;
		cout << "b = " << b << endl;
		cout << "c = " << c << endl;
	}
    return 0;
}

运行结果：

在for循环内：
a = 100
b = 200
c = 300

分析

这里的 a,b,c 都是 for 循环的局部变量，出了 for 循环，这里的 a,b,c 即消亡了，若在 for 循环外面进行打印 a,b,c 的值，程序会报错；

#include<iostream>
#include<string.h>
using namespace std;
int main()
{
	for(int i=1;i<=1;i++){
		int a = 100;
		int b = 200;
		int c = 300;
		cout << "在for循环内：" << endl;
		cout << "a = " << a << endl;
		cout << "b = " << b << endl;
		cout << "c = " << c << endl;
	}
	cout << "在main函数内：" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	return 0;
}

警告

程序报错,此时 16 行，17 行，18 行的 a,b,c 未定义；再次验证了局部变量的作用；

全局变量

全局变量是定义在函数外部，通常是在程序的顶部。全局变量在整个程序生命周期内都是有效的，在任意的函数内部能访问全局变量。

全局变量可以被任何函数访问。也就是说，全局变量在声明后整个程序中都是可用的。

全局变量 示例代码

#include<bits/stdc++.h>
using namespace std;
int sum;
int main()
{
    int a = 10;
	int b = 20;
	sum = a + b;
	cout << "sum = " << sum << endl;
    return 0;
}

运行结果：

sum = 30

分析

这里的 sum 是全局变量，a,b 是 main 函数内部的局部变量，验证了全局变量在声明后整个程序中都是可用的；

局部变量 和 局部变量重名怎么处理？

在程序中，局部变量和全局变量的名称可以相同，但是在函数内，如果两个名字相同，会优先使用局部变量值，全局变量不会被使用。

我们来看一个例子：

全局变量 示例代码

#include<bits/stdc++.h>
using namespace std;
int sum = 1;
void func(int x,int y)
{
	int sum = 0;
	sum = x + y;
	cout << "func函数内：sum = " << sum << endl;
}
int main()
{
    func(10,20);
	cout << "main函数内: " << endl;
	cout << "sum = " << sum << endl;
    return 0;
}

运行结果：

func函数内：sum = 30
main函数内:
sum = 1

分析

可以看的出来，程序执行之后，全局变量 sum 的值是 1，局部变量 sum 的值是 30；
在 func 函数内部，打印的 sum 值是函数内部定义的 sum，而不是全局变量 sum；